package cn.hl.hm.util;
import java.math.BigDecimal;
import java.text.DecimalFormat;
import java.util.ArrayList;
import java.util.HashSet;
import java.util.List;
import java.util.Random;
import java.util.UUID;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

/**
 * 字符串处理工具类：<br>
 * 功能：长度，正则表达式等
 * 时间：2016.10.20
 * @author Liuyc
 */

public class StringUtil {
	
	private static final String RANDOM_BASE = "abcdefghijklmnopqrstuvwxyz0123456789";
	

	/** 
	 * 比较字符的大小,前者大则返回一个正数,后者大返回一个负数,相等则返回0 
	 * @param str1 
	 * @param str2 
	 * @return getProjectListByOrgId
	 */  
	public static int compareString(String str1, String str2) {  
	    if (str1 == null || str2 == null) {  
	        return 0;
	    } 
	    String[] versionArray1 = str1.split("\\.");//注意此处为正则匹配，不能用"."；  
	    String[] versionArray2 = str2.split("\\.");  
	    int idx = 0;  
	    int minLength = Math.min(versionArray1.length, versionArray2.length);//取最小长度值  
	    int diff = 0;  
	    while (idx < minLength  
	            && (diff = versionArray1[idx].length() - versionArray2[idx].length()) == 0//先比较长度  
	            && (diff = versionArray1[idx].compareTo(versionArray2[idx])) == 0) {//再比较字符  
	        ++idx;  
	    }  
	    //如果已经分出大小，则直接返回，如果未分出大小，则再比较位数，有子版本的为大；  
	    diff = (diff != 0) ? diff : versionArray1.length - versionArray2.length;  
	    return diff;  
	}  
	
	/**
	 * 生成指定长度的顺序数，如：0000001，000000010
	 * @param i
	 * @return
	 */
	public static String createOrderString(int i,int iLength)
	{
		DecimalFormat df = null;
		
		String pattern=StringUtil.getRandomString(iLength, "0");
		
		df = new DecimalFormat(pattern);
		String str = df.format(i);

		return str;
	}
	
	
	/**
	 * 过虑重复的字符串
	 * @return
	 */
	public static List<String> FilterRepeatString(List<String>lstStrings)
	{
		List<String> listWithoutDup = new ArrayList<>(new HashSet<>(lstStrings));
		return listWithoutDup;
	}
	
	/**
	 * 替换字符串中多个空格成一个空格
	 * @param str
	 * @return
	 */
	
	public static String replaceSpaceMore2One(String str)
	{
		String result= "";
		Pattern p = Pattern.compile("\\s+");
		Matcher m = p.matcher(str);
		result= m.replaceAll(" ");
		return result;
	}

	
	/**
	 * 生成随机数
	 * @param length 随机数长度
	 * @return
	 */
	public static String getRandomString(int length) { //length表示生成字符串的长度
	    return getRandomString(length,RANDOM_BASE);
	 }  
	
	/**
	 * 生成随机长度的字符串
	 * @param length 随机数长度
	 * @param sBase 随机数生成的基础字符，如：！@#￥……&*（）—中生成随机数
	 * @return
	 */
	public static String getRandomString(int length,String sBase) { //length表示生成字符串的长度
		if(sBase == null || sBase.length() == 0){
			sBase = RANDOM_BASE;
		}
	    Random random = new Random();   
	    StringBuffer sb = new StringBuffer();   
	    for (int i = 0; i < length; i++) {   
	        int number = random.nextInt(sBase.length());   
	        sb.append(sBase.charAt(number));   
	    }   
	    return sb.toString();   
	 }  
	
	/**
	 * 生成随机数长度的数字字符串
	 * @param length 随机数长度
	 * @return
	 */
	public static String getRandomNumberString(int length) { //length表示生成字符串的长度
		String sBase="0123456789";
	    return getRandomString(length,sBase);
	 }  
	
	/**
	 * 生成指定长度的字符串
	 * @param length 长度
	 * @param sBase 生成的基础字符，如：！@#￥……&*（）—中生成随机数
	 * @return
	 */
	public static String String(String sBase,int length) { //length表示生成字符串的长度
		if(sBase == null || sBase.length() == 0){
			return "";
		}

	    StringBuffer sb = new StringBuffer();   
	    for (int i = 0; i < length; i++) {   
	        sb.append(sBase);
	    }   
	    return sb.toString();   
	 }  
	
	
	/**
	 * 截取字符串左侧
	 * @param str
	 * @param length
	 * @return
	 */
	public static String left(String str,int length)
	{
		if(length>0)
		{
			//改一下这个涵数
			if(str.length()>=length)
				return str.substring(0, length);
			else
			{
				if(str.length()>0)
					return str;
				else
					return "";
			}
		}
		return "";
	}
	
	/**
	 * 截取字符串右侧
	 * @param str
	 * @param length
	 * @return
	 */
	public static String right(String str,int length)
	{
		String result="";
		if(str.length()>=length)
		{
			int start=str.length()-length;

			result=str.substring(start, str.length());
		}
		else
		{
			if(str.length()>0)
				result= str;
		}
			
		return result;
	}
	
	
	/**
	 * 截取字符串
	 * @param str
	 * @param length
	 * @return
	 */
	public static String subString(String str,int start,int length)
	{
		String result="";
		
		
		if(str.length()>=length)
		{
			int i=0;
			int strLength=str.length();
			if((start+length)>strLength)
				length=strLength-start;
			if (length<0)
				length=0;
			try
			{
				result=str.substring(start, start+length);
			}catch(Exception e)
			{
				e.printStackTrace();
			}
		}
		return result;
	}
	
    /**
     * 将十六进制字符转换成字节数组（二进制）
     * @param strIn  要转换的字符串
     * @return 转换后的数组
     * @throws Exception
     */
    public static byte[] hexStr2ByteArr(String strIn) throws Exception {
        byte[] arrB = strIn.getBytes();
        int iLen = arrB.length;

        byte[] arrOut = new byte[iLen / 2];
        for (int i = 0; i < iLen; i = i + 2) {
            String strTmp = new String(arrB, i, 2);
            arrOut[i / 2] = (byte) Integer.parseInt(strTmp, 16);
        }
        return arrOut;
    }
	
    /**
     * 将字节数（二进制）转换变十六进制字符
     * @param arrB 要转换的字节
     * @return 转换后的进制字符
     * @throws Exception
     */
    public static String byteArr2HexStr(byte[] arrB) throws Exception {
        int iLen = arrB.length;
        StringBuffer sb = new StringBuffer(iLen * 2);
        for (int i = 0; i < iLen; i++) {
            int intTmp = arrB[i];
            while (intTmp < 0) {
                intTmp = intTmp + 256;
            }
            if (intTmp < 16) {
                sb.append("0");
            }
            sb.append(Integer.toString(intTmp, 16));
        }
        return sb.toString();
    }

    
	/**
	 * 生成UUID
	 * @return
	 */
	public static String get32UUID() {
		String uuid = UUID.randomUUID().toString().trim().replaceAll("-", "");
		return uuid;
	}
    /**
     * 过滤空NULL
     * @param str
     * @return 
     */
    public static String FilterNull(String str) {
    	str=str != null && !"null".equals(str.toString()) ? str.toString().trim() : "" ;
    	str=str.replaceAll("[\\t\\n\\r]", "");//将内容区域的回车换行去除
        return str;
    }
    
    /**
     * 是否为空
     * @param str
     * @return
     */
    public static boolean isEmpty(String str) {
        if (str == null) {
            return true;
        }
        if ("".equals(FilterNull(str.toString()))) {
            return true;
        } else {
            return false;
        }
    }
    
    /**
     * 是否不为空
     * @param str
     * @return
     */
    public static boolean isNotEmpty(String str) {
        if (str == null) {
            return false;
        }
        if ("".equals(FilterNull(str.toString()))) {
            return false;
        } else {
            return true;
        }
    }
    
    /**
     * 是否可转化为数字
     * @param str
     * @return
     */
    public static boolean isNum(String str) {
        try {
            new BigDecimal(str.toString());
            return true;
        } catch (Exception e) {
        }
        return false;
    }
    
    /**
     * 是否可转化为Long型数字
     * @param str
     * @return
     */
    public static boolean isLong(String str) {
        try {
            new Long(str.toString());
            return true;
        } catch (Exception e) {
        }
        return false;
    }
    
    /**
     * 转化为Double型数字, 不可转化时返回0
     * @param str
     * @return
     */
    public static double toDouble(String str) {
        if (isLong(str)) {
            return new Double(str.toString());
        } else {
            return 0L;
        }
    }
    
    /**
     * 是否可转化为Double型数字
     * @param str
     * @return
     */
    public static boolean isDouble(String str) {
        try {
            new Double(str.toString());
            return true;
        } catch (Exception e) {
        }
        return false;
    }
    
    /**
     * 转化为Long型数字, 不可转化时返回0
     * @param str
     * @return
     */
    public static Long toLong(String str) {
        if (isLong(str)) {
            return new Long(str.toString());
        } else {
            return 0L;
        }
    }
    
    
    /**
     * 转化为int型数字, 不可转化时返回0
     * @param str
     * @return
     */
    public static int toInt(String str) {
        if (isNum(str)) {
            return new Integer(str.toString());
        } else {
            return 0;
        }
    }
    
    
    /**
     * 转化为int型数字, 不可转化时返回0
     * @param str
     * @return
     */
    public static int ascii(String str)  
    {  
        char[] chars = str.toCharArray();   
        return (int)chars[0];
    }  
    
    /**
     * 将ASCII转成字符
     * @param value
     * @return
     */
    public static String chr(int value)  
    {  
    	StringBuffer sbu = new StringBuffer();  
    	sbu.append((char)value);
    	return sbu.toString();
    }    
    /**
     * 按字节截取字符串
     * @param strString
     * @param len
     * @return
     */
    public static String subStringByByte(String strString, int len) {
        if (strString == null) {
            return "";
        }
        String str = strString.toString();
        String result = null;
        if (str != null) {
            byte[] a = str.getBytes();
            if (a.length <= len) {
                result = str;
            } else if (len > 0) {
                result = new String(a, 0, len);
                int length = result.length();
                if (str.charAt(length - 1) != result.charAt(length - 1)) {
                    if (length < 2) {
                        result = null;
                    } else {
                        result = result.substring(0, length - 1);
                    }
                }
            }
        }
        return result;
    }

    /**
     * 表达式_添加
     * @param commaexpress 原逗号表达式 如 A,B
     * @param newelement   新增元素 C
     * @param splitStr  分隔符
     * @return A,B,C
     */
    public static String split_add(String commaexpress, String newelement,String splitStr) {
        return split_regulate(FilterNull(commaexpress) + splitStr.toString() + FilterNull(newelement),splitStr.toString());
    }

    /**
     * 表达式_添加（默认添加 逗号 分隔符）
     * @param commaexpress 原逗号表达式 如 A,B
     * @param newelement   新增元素 C
     * @return A,B,C
     */
    public static String comma_add(String commaexpress, String newelement) {
        return comma_regulate(FilterNull(commaexpress) + "," + FilterNull(newelement));
    }
    
    
    /**
     * 表达式_删除
     * @param commaexpress  原逗号表达式 如 A,B,C
     * @param delelement 删除元素 C,A
     * @param splitStr  分隔符
     * @return B
     */
    public static String split_del(String commaexpress, String delelement,String splitStr) {
        if ((commaexpress == null) || (delelement == null) || (commaexpress.trim().equals(delelement.trim()))) {
            return "";
        }
        String[] deletelist = delelement.split(splitStr.toString());
        String result = commaexpress;
        for (String delstr : deletelist) {
            result = split_delOne(result, delstr,splitStr.toString());
        }
        return result;
    }
    
    /**
     * 表达式_删除（默认 逗号 分隔符）
     * @param commaexpress  原逗号表达式 如 A,B,C
     * @param delelement 删除元素 C,A
     * @return B
     */
    public static String comma_del(String commaexpress, String delelement) {
        if ((commaexpress == null) || (delelement == null) || (commaexpress.trim().equals(delelement.trim()))) {
            return "";
        }
        String[] deletelist = delelement.split(",");
        String result = commaexpress;
        for (String delstr : deletelist) {
            result = comma_delOne(result, delstr);
        }
        return result;
    }
    
    
    /**
     * 表达式_单一删除（默认 逗号 分隔符）
     * @param commaexpress  原逗号表达式 如 A,B,C
     * @param delelement 删除元素 C
     * @return A,B
     */
    public static String comma_delOne(String commaexpress, String delelement) {
        if ((commaexpress == null) || (delelement == null) || (commaexpress.trim().equals(delelement.trim()))) {
          return "";
        }
        String[] strlist = commaexpress.split(",");
        StringBuffer result = new StringBuffer();
        for (String str : strlist) {
          if ((!str.trim().equals(delelement.trim())) && (!"".equals(str.trim()))) {
            result.append(str.trim() + ",");
          }
        }
        return result.toString().substring(0, result.length() - 1 > 0 ? result.length() - 1 : 0);
      }

    
    /**
     * 逗号表达式_单一删除
     * @param commaexpress  原逗号表达式 如 A,B,C
     * @param delelement 删除元素 C
     *  @param splitStr  分隔符
     * @return A,B
     */
    public static String split_delOne(String commaexpress, String delelement,String splitStr) {
        if ((commaexpress == null) || (delelement == null) || (commaexpress.trim().equals(delelement.trim()))) {
          return "";
        }
        String[] strlist = commaexpress.split(splitStr.toString());
        StringBuffer result = new StringBuffer();
        for (String str : strlist) {
          if ((!str.trim().equals(delelement.trim())) && (!"".equals(str.trim()))) {
            result.append(str.trim() + splitStr.toString());
          }
        }
        return result.toString().substring(0, result.length() - 1 > 0 ? result.length() - 1 : 0);
      }
    
    /**
     * 表达式_判断是否包含元素 （默认 逗号 分隔符）
     * @param commaexpress 逗号表达式 A,B,C
     * @param element C
     * @return true
     */
    public static boolean comma_contains(String commaexpress, String element) {
        boolean flag = false;
        commaexpress = FilterNull(commaexpress);
        element = FilterNull(element);
        if (!"".equals(commaexpress) && !"".equals(element)) {
            String[] strlist = commaexpress.split(",");
            for (String str : strlist) {
                if (str.trim().equals(element.trim())) {
                    flag = true;
                    break;
                }
            }
        }
        return flag;
    }

    
    /**
     * 表达式_判断是否包含元素 
     * @param commaexpress 逗号表达式 A,B,C
     * @param element C
     * @param splitStr  元素的分隔符
     * @return true
     */
    public static boolean split_contains(String commaexpress, String element,String splitStr) {
        boolean flag = false;
        commaexpress = FilterNull(commaexpress);
        element = FilterNull(element);
        if (!"".equals(commaexpress) && !"".equals(element)) {
            String[] strlist = commaexpress.split(splitStr.toString());
            for (String str : strlist) {
                if (str.trim().equals(element.trim())) {
                    flag = true;
                    break;
                }
            }
        }
        return flag;
    }
    
    /**
     * 表达式_取交集 （默认 逗号 分隔符）
     * @param commaexpressA 逗号表达式1  A,B,C
     * @param commaexpressB 逗号表达式2  B,C,D
     * @return B,C
     */
    public static String comma_intersect(String commaexpressA, String commaexpressB) {
        commaexpressA = FilterNull(commaexpressA);
        commaexpressB = FilterNull(commaexpressB);
        StringBuffer result = new StringBuffer();
        String[] strlistA = commaexpressA.split(",");
        String[] strlistB = commaexpressB.split(",");
        for (String boA : strlistA) {
            for (String boB : strlistB) {
                if (boA.trim().equals(boB.trim())) {
                    result.append(boA.trim() + ",");
                }
            }
        }
        return comma_regulate(result.toString());
    }

    
    /**
     * 表达式_取交集
     * @param commaexpressA 逗号表达式1  A,B,C
     * @param commaexpressB 逗号表达式2  B,C,D
     * @param splitStr  分隔符
     * @return B,C
     */
    public static String split_intersect(String commaexpressA, String commaexpressB,String splitStr) {
        commaexpressA = FilterNull(commaexpressA);
        commaexpressB = FilterNull(commaexpressB);
        StringBuffer result = new StringBuffer();
        String[] strlistA = commaexpressA.split(splitStr.toString());
        String[] strlistB = commaexpressB.split(splitStr.toString());
        for (String boA : strlistA) {
            for (String boB : strlistB) {
                if (boA.trim().equals(boB.trim())) {
                    result.append(boA.trim() + splitStr.toString());
                }
            }
        }
        return split_regulate(result.toString(),splitStr.toString() );
    }
    
    
    /**
     * 表达式_规范 （默认 逗号 分隔符）
     * @param commaexpress  逗号表达式  ,A,B,B,,C
     * @return A,B,C
     */
    public static String comma_regulate(String commaexpress) {
        commaexpress = FilterNull(commaexpress);
        String[] strlist = commaexpress.split(",");
        StringBuffer result = new StringBuffer();
        for (String str : strlist) {
        	//如果str 不等于“” 或null ，或者不在目标字符串中存在，则添加。
            if (!("".equals(str.trim())) && !("," + result.toString() + ",").contains("," + str + ",") && !"null".equals(str)) {
                result.append(str.trim() + ",");
            }
        }
        return result.toString().substring(0, (result.length() - 1 > 0) ? result.length() - 1 : 0);
    }

    /**
     * 表达式_规范 
     * @param commaexpress  逗号表达式  ,A,B,B,,C
     * @param splitStr  分隔符
     * @return A,B,C
     */
    public static String split_regulate(String commaexpress,String splitStr) {
        commaexpress = FilterNull(commaexpress);
        String[] strlist = commaexpress.split(splitStr.toString());
        StringBuffer result = new StringBuffer();
        for (String str : strlist) {
        	//如果str 不等于“” 或null ，或者不在目标字符串中存在，则添加。
            if (!("".equals(str.trim())) && !(splitStr.toString() + result.toString() + 
            		splitStr.toString() ).contains(splitStr.toString() + str + splitStr.toString() ) && !"null".equals(str)) {
                result.append(str.trim() + splitStr.toString() );
            }
        }
        return result.toString().substring(0, (result.length() - 1 > 0) ? result.length() - 1 : 0);
    }
    
    
    /**
     * 字符串_反转  
     * @param commaexpress A,B,C
     * @return C,B,A
     */
    public static String reverse(String commaexpress) {
    	return new StringBuffer(commaexpress).reverse().toString();
    }

    /**
     * 表达式_反转  
     * @param commaexpress A,B,C
     * @param splitStr  分隔符
     * @return C,B,A
     */
    public static String split_reverse(String commaexpress,String splitStr) {
        commaexpress = FilterNull(commaexpress);
        String[] ids = commaexpress.split(splitStr.toString());
        StringBuffer str = new StringBuffer();
        for (int i = ids.length - 1; i >= 0; i--) {
            str.append(ids[i] + splitStr.toString());
        }
        return split_regulate(str.toString(),splitStr.toString());
    }
    
    
    /**
     * 逗号表达式_反转  
     * @param commaexpress A,B,C
     * @return C,B,A
     */
    public static String comma_reverse(String commaexpress) {
        commaexpress = FilterNull(commaexpress);
        String[] ids = commaexpress.split(",");
        StringBuffer str = new StringBuffer();
        for (int i = ids.length - 1; i >= 0; i--) {
            str.append(ids[i] +",");
        }
        return comma_regulate(str.toString());
    }
    
    
    /**
     * 逗号表达式_获取首对象  （默认 逗号 分隔符）
     * @param commaexpress A,B,C
     * @return A
     */
    public static String comma_first(String commaexpress) {
        commaexpress = FilterNull(commaexpress);
        String[] ids = commaexpress.split(",");
        System.out.println("length:" + ids.length);
        if ((ids != null) && (ids.length > 0)) {
            return ids[0];
        }
        return null;
    }

    /**
    * 表达式_获取首对象 
    * @param commaexpress A,B,C
    * @param splitStr  分隔符
    * @return A
    */
   public static String split_first(String commaexpress,String splitStr) {
       commaexpress = FilterNull(commaexpress);
       String[] ids = commaexpress.split(splitStr.toString());
       System.out.println("length:" + ids.length);
       if ((ids != null) && (ids.length > 0)) {
           return ids[0];
       }
       return null;
   }
    /**
     * 逗号表达式_获取尾对象  （默认 逗号 分隔符）
     * @param commaexpress A,B,C
     * @return C
     */
    public static String comma_last(String commaexpress) {
        commaexpress = FilterNull(commaexpress);
        String[] ids = commaexpress.split(",");
        if ((ids != null) && (ids.length > 0)) {
            return ids[(ids.length - 1)];
        }
        return null;
    }

    /**
     * 逗号表达式_获取尾对象  （默认 逗号 分隔符）
     * @param commaexpress A,B,C
     * @param splitStr  分隔符
     * @return C
     */
    public static String split_last(String commaexpress,String splitStr) {
        commaexpress = FilterNull(commaexpress);
        String[] ids = commaexpress.split(splitStr.toString());
        if ((ids != null) && (ids.length > 0)) {
            return ids[(ids.length - 1)];
        }
        return null;
    }
    
    
    /**
     * 替换字符串,支持字符串为空的情形
     * @param strData
     * @param regex   规换前字符
     * @param replacement   替换后字符
     * @return
     */
    public static String replace(String strData, String regex, String replacement) {
        return strData == null ? "" : strData.replaceAll(regex, replacement);
    }
        
    /**
     * 字符串转为HTML显示字符
     * @param strData
     * @return
     */
    public static String String2HTML(String strData){
        if( strData == null || "".equals(strData) ){
            return "" ;
        }
        strData = replace(strData, "&", "&amp;");
        strData = replace(strData, "<", "&lt;"); 
        strData = replace(strData, ">", "&gt;");
        strData = replace(strData, "\"", "&quot;");
        return strData;
    }
        
    /**
     * 过滤特殊符号 
     * @param str   要过滤的字符
     * @return
     */
    public static String regex(String str){
        Pattern pattern = Pattern.compile("[0-9-:/ ]");// 中文汉字编码区间
        Matcher matcher;
        char[] array = str.toCharArray();
        for (int i = 0; i < array.length; i++) {
            matcher = pattern.matcher(String.valueOf(array[i]));
            if (!matcher.matches()) {// 空格暂不替换
                str = str.replace(String.valueOf(array[i]), "");// 特殊字符用空字符串替换
            }
        }
         
        return str;    
    }
    
    /**
     * 插入数据到一个字符串中
     * @param commaexpress
     * @param newelement
     * @param index
     * @return
     */
    public static String insert(String commaexpress, String newelement,int index){
        int length = commaexpress.length();
        if ( index > length ) {
            index = length;
        }else if ( index < 0){
            index = 0;
        }
        String result = commaexpress.substring(0, index) + newelement + commaexpress.substring(index, commaexpress.length());
        return result;
    }

    /**
     * 得到大括号中的内容
     * @param str
     * @return
     */
    public static String getBrackets(String str) {
        int a = str.indexOf("{");
        int c = str.indexOf("}");
        if (a >= 0 && c >= 0 & c > a) {
            return (str.substring(a + 1, c));
        } else {
            return str;
        }
    }

    /**
     * 计算text的长度（一个中文算两个字符）
     * @param text
     * @return
     */
    public static int getLength(String text) {
        int length = 0;
        for (int i = 0; i < text.length(); i++) {
            if (new String(text.charAt(i) + "").getBytes().length > 1) {
                length += 2;
            } else {
                length += 1;
            }
        }
        return length / 2;
    }
    
}
